  Page({
    /**
     * 页面的初始数据
     */
    data: {
      val: '',
      carousels: '',
      list: '',
      //用于储存获取到的订单
      list1: '',
      all: '',
      goodsstat: false,
      goodsstats: true,
      deletes: [],
      prompt: [],
      orderTotals: [],
      judge: true,
      specMultipleValue: ''
    },

    // 获取轮播图
    getCarousels: function () {
      var that = this;
      wx.request({
        url: 'https://199shq.com/api/carousels',
        method: 'GET',
        header: {
          'Content-Type': 'application/json',
          'token': wx.getStorageSync('token'),
        },
        success: function (res) {
          console.log(res.data.data[0]);
          var list = res.data;
          if (list == null) {
            var toastText = '数据获取失败';
            wx.showToast({
              title: toastText,
              icon: '',
              duration: 2000,
            });
          } else {
            that.setData({
              carousels: res.data.data[0],
            });
          }
        },
      });
    },
    detail: function (e) {
      console.log(e.currentTarget.dataset.goodsid)
      console.log(e.currentTarget.dataset.storeid)
      wx.navigateTo({
        url: `/pages/category/category?value=${e.currentTarget.dataset.goodsid}&value2=${e.currentTarget.dataset.storeid}`,
      });
    },
    // 获取门店详情数据
    getdata: function () {
      var that = this;
      wx.request({
        url: 'https://199shq.com/api/stores',
        method: 'GET',
        header: {
          'Content-Type': 'application/json',
          'token': wx.getStorageSync('token'),
        },
        success: function (res) {
          console.log(res.data);
          var list = res.data;
          if (list == null) {
            var toastText = '数据获取失败';
            wx.showToast({
              title: toastText,
              icon: '',
              duration: 2000,
            });
          } else {
            that.setData({
              list: res.data,
            });
          }
        },
      });
    },

    // 点击事件；去商铺
    tapMe1: function (e) {
      var id = e.currentTarget.dataset.id; // 获取点击的数据ID
      // 判断用户是否已登录
      var userInfo = getApp().globalData.userInfo;
      console.log(userInfo)

      // 判断用户是否已登录
      if (!userInfo) {
        // 如果用户未授权登录，则弹出提示框
        wx.showModal({
          title: '提示',
          content: '请先授权登录账号',
          showCancel: false,
          success: (res) => {
            // 用户点击确定
            if (res.confirm) {
              // 跳转到登录页
              wx.navigateTo({
                url: '/pages/login/login'
              });
            }
          }
        });
      } else {
        // 如果用户已授权登录，则跳转到对应页面
        wx.navigateTo({
          url: '../detail/detail?value=' + id,
        });
      }
    },

    goto: function () {
      wx.switchTab({
        url: '/pages/index/index'
      });
    },

    //定义一个函数，用来控制购物车中的商品数量的减少
  // 修复后的减号方法


    //定义一个函数，用来控制购物车中的商品数量的增加
    increase: function (e) {
      console.log("加号操作，当前合并商品数据:", e.currentTarget.dataset);
      var that = this;
    
      // 获取合并商品数据（含原始商品列表）
      var mergedGoods = e.currentTarget.dataset.mergedGoods;
      if (!mergedGoods || !mergedGoods.childItems || mergedGoods.childItems.length === 0) {
        console.error("未获取到原始商品数据");
        wx.showToast({ title: '数据异常', icon: 'none' });
        return;
      }
    
      // 选择第一个原始商品进行操作
      var targetChild = mergedGoods.childItems[0];
      var targetId = targetChild.id;
      var currentChildNumber = targetChild.number;
    
      // 计算新数量（只加当前原始商品的数量）
      var newChildNumber = currentChildNumber + 1;
      console.log(`原始商品${targetId}数量变化：${currentChildNumber} → ${newChildNumber}`);
    
      // 更新原始商品的数量
      wx.request({
        url: `https://199shq.com/api/shoppingCart?number=${newChildNumber}&id=${targetId}`,
        method: 'PUT',
        header: {
          'Content-Type': 'application/json',
          'token': wx.getStorageSync('token')
        },
        success: function () {
          that.getOrder(); // 刷新后总数量会增加1
        },
        fail: function () {
          wx.showToast({ title: '增加失败', icon: 'none' });
        }
      });
    },
    
    showConfirmationDialog() {
      let deletes = this.data.deletes
      let prompt = this.data.prompt
      let that = this;
      console.log(prompt)
      const result = prompt.join(',');
      // const result = prompt.join(','); 
      if (deletes.length > 0) {
        wx.showModal({
          title: '确认操作',
          content: `您订单中存在已下架商品${result}是否删除，删除后才能正常支付？`,
          success(res) {
            if (res.confirm) {
              console.log('用户点击确定');
              for (let i = 0; i < deletes.length; i++) {
                console.log(deletes[i])
                wx.request({
                  url: `https://199shq.com/api/shoppingCart/${deletes[i]}`,
                  method: 'DELETE',
                  header: {
                    'Content-Type': 'application/x-www-form-urlencoded',
                    'token': wx.getStorageSync('token')
                  },
                  success: (res) => {
                    // var toastText = '存在商品已下架，暂无法支付';
                    wx.showToast({
                      title: `删除成功`,
                      icon: '',
                      duration: 2000
                    });
                    that.setData({
                      judge: true,
                    });
                    that.getOrder()
                  },
                  fail: (error) => {
                    console.log(error); // 请求失败的处理
                  }
                });
              }

              // 处理确认逻辑  
            } else if (res.cancel) {
              console.log('用户点击取消');
              // 处理取消逻辑  
            }
          }
        });
      }

    },
    //定义一个函数，获取到所有
  // 修复后的 getOrder 方法（核心改商品合并时的数量计算）
  getOrder: function () {
    var that = this;
    var app = getApp();
    // 1. 先校验用户ID是否存在（避免因ID错误导致获取不到数据）
    if (!app.globalData.userInfo || !app.globalData.userInfo.wxUserId) {
      console.error("用户ID不存在，无法获取购物车数据");
      that.setData({ all: [], goodsstat: true }); // 显示空购物车
      return;
    }
    var id = String(app.globalData.userInfo.wxUserId); // 强制转为字符串，避免类型错误

    wx.request({
      url: `https://199shq.com/api/shoppingCart/${id}`,
      method: 'GET',
      header: {
        'Content-Type': 'application/json',
        'token': wx.getStorageSync('token')
      },
      success: function (res) {
        // 2. 校验接口返回是否正常（避免因后端返回格式错误导致处理失败）
        if (!res.data || !res.data.data || !Array.isArray(res.data.data)) {
          console.error("接口返回数据格式错误:", res.data);
          that.setData({ all: [], goodsstat: true });
          return;
        }
        var list = res.data.data;
        console.log("原始购物车数据（长度）:", list.length, "原始数据:", list);

        // 3. 按门店分类（强制统一storeId为字符串，避免数字/字符串差异导致分类错误）
        var storeMap = {};
        for (var i = 0; i < list.length; i++) {
          var item = list[i];
          // 强制转换storeId为字符串（关键：避免123和"123"被视为不同门店）
          var storeId = String(item.storeId || 'unknown'); 
          if (!storeMap[storeId]) {
            storeMap[storeId] = [];
          }
          storeMap[storeId].push(item);
        }

        // 4. 合并商品（确保相同商品生成相同的uniqueKey）
        var mergedData = [];
        for (var storeId in storeMap) {
          var storeGoods = storeMap[storeId];
          var goodsMap = new Map();

          for (var j = 0; j < storeGoods.length; j++) {
            var goods = storeGoods[j];
            // 统一处理关键字段（转为字符串+去空，确保相同商品key一致）
            var goodsId = String(goods.goodsId || '');
            var specName = (goods.goodsSpecName || '').toString().trim(); // 去除空格，避免"规格1 "和"规格1"被视为不同
            var specMultiple = (goods.specMultipleValue || '').toString().trim();
            
            // 生成唯一键（严格一致）
            var uniqueKey = `${storeId}-${goodsId}-${specName}-${specMultiple}`;
            var currentGoodsNumber = Number(goods.goodsNumber) || 0;

            console.log(`第${j+1}个商品的key:`, uniqueKey, "数量:", currentGoodsNumber); // 调试用

            if (goodsMap.has(uniqueKey)) {
              // 已存在：合并数量和原始ID
              var existingGoods = goodsMap.get(uniqueKey);
              existingGoods.totalNumber = Number(existingGoods.totalNumber) + currentGoodsNumber;
              console.log(existingGoods.totalNumber)
              console.log(currentGoodsNumber)
              existingGoods.childItems.push({
                id: goods.id,
                number: currentGoodsNumber
              });
            } else {
              // 新商品：初始化（确保字段完整）
              goodsMap.set(uniqueKey, {
                ...goods,
                goodsNumber: currentGoodsNumber, // 合并后显示的数量（WXML绑定用）
                childItems: [{ // 原始商品ID和数量（操作用）
                  id: goods.id,
                  number: currentGoodsNumber
                }],
                // 补充门店ID（避免后续取storeId时为undefined）
                storeId: storeId
              });
            }
          }

          // 将当前门店的合并商品添加到结果（过滤空商品）
          var storeMerged = Array.from(goodsMap.values()).filter(goods => goods.totalNumber > 0);
          if (storeMerged.length > 0) {
            mergedData.push(storeMerged);
          }
        }

        // 5. 校验合并后的数据结构（确保二维数组格式正确）
        console.log("合并后的数据（长度）:", mergedData.length, "合并数据:", mergedData);
        that.setData({ 
          all: mergedData, 
          goodsstat: mergedData.length === 0 // 当合并后无商品时显示空购物车
        });
        that.calculateTotal();
      },
      fail: function (error) {
        // 6. 接口请求失败时的处理（避免白屏）
        console.error("获取购物车数据失败:", error);
        that.setData({ all: [], goodsstat: true });
        wx.showToast({ title: '获取购物车失败', icon: 'none' });
      }
    });
  },


  // 同步修复 decrease 方法（确保基于正确的数字类型计算）
  // 在 decrease 方法的删除商品逻辑中，强化数组刷新
  decrease: function (e) {
    console.log("减号操作，当前合并商品数据:", e.currentTarget.dataset);
    var that = this;

    // 获取合并商品数据（含原始商品列表）
    var mergedGoods = e.currentTarget.dataset.mergedGoods;
    if (!mergedGoods || !mergedGoods.childItems || mergedGoods.childItems.length === 0) {
      console.error("未获取到原始商品数据");
      wx.showToast({ title: '数据异常', icon: 'none' });
      return;
    }

    // 选择第一个原始商品进行操作
    var targetChild = mergedGoods.childItems[0];
    var targetId = targetChild.id;
    var currentChildNumber = targetChild.number;

    // 计算新数量（只减当前原始商品的数量）
    var newChildNumber = currentChildNumber - 1;
    console.log(`原始商品${targetId}数量变化：${currentChildNumber} → ${newChildNumber}`);

    if (newChildNumber <= 0) {
      // 原始商品数量为0，删除该原始商品
      wx.request({
        url: `https://199shq.com/api/shoppingCart/${targetId}`,
        method: 'DELETE',
        header: {
          'Content-Type': 'application/json',
          'token': wx.getStorageSync('token')
        },
        success: function () {
          // 1. 重新获取购物车数据（核心：从后端拉取最新数据，确保数组同步）
          that.getOrder();

          // 2. （可选）前端临时过滤数组，优化体验（防止网络延迟导致的界面残留）
          const currentAll = that.data.all;
          if (currentAll.length > 0) {
            // 遍历门店数组，过滤已删除商品
            const updatedAll = currentAll.map(storeGoods => { 
              return storeGoods.filter(goods => {
                // 检查商品的原始ID是否包含被删除的targetId
                return !goods.childItems.some(item => item.id === targetId);
              });
            }).filter(storeGoods => storeGoods.length > 0); // 过滤空门店

            // 临时更新界面（后续会被getOrder的结果覆盖，仅优化体验）
            // that.setData({ all: updatedAll });
            that.calculateTotal(); // 重新计算总价
          }
        },
        fail: function () {
          wx.showToast({ title: '删除失败', icon: 'none' });
        }
      });
    } else {
      // 更新原始商品的数量（只改这一个）
      wx.request({
        url: `https://199shq.com/api/shoppingCart?number=${newChildNumber}&id=${targetId}`,
        method: 'PUT',
        header: {
          'Content-Type': 'application/json',
          'token': wx.getStorageSync('token')
        },
        success: function () {
          that.getOrder(); // 刷新后总数量会减少1
        },
        fail: function () {
          wx.showToast({ title: '减少失败', icon: 'none' });
        }
      });
    }
  },


    //当用户点击了取消订单时在数据库逻辑删除
    delorder: function (e) {
      console.log(e.currentTarget.dataset.item);
      var item = e.currentTarget.dataset.item;
      var that = this;
      wx.showModal({
        title: '提示',
        content: '是否删除',
        success(res) {
          if (res.confirm) {
            for (var i = 0; i < item.length; i++) {
              wx.request({
                url: `https://199shq.com/api/shoppingCart/${item[i].id}`,
                method: 'DELETE',
                header: {
                  'Content-Type': 'application/json',
                  'token': wx.getStorageSync('token')
                },
                success: function (res) {
                  console.log(res.data.data);
                  var list = res.data.data;
                  if (list == null) {
                    var toastText = '数据获取失败';
                    wx.showToast({
                      title: 'toastText',
                      icon: '',
                      duration: 2000
                    });
                  } else {
                    that.getOrder();
                  }
                }
              })
            }
          } else if (res.cancel) {
            return false
          }
        }
      })
    },

    // 联系商家
    delorder1() {
      // 如果用户已授权登录，则跳转到对应页面
      console.log('进入')
      wx.navigateTo({
        url: '/pages/service/service'
      });
    },

    //立即支付
    //立即支付
    delorder2(e) {
      console.log(e)
      var that = this;
      var app = getApp();
      var id = app.globalData.userInfo.wxUserId;
      wx.request({
        url: `https://199shq.com/api/shoppingCart/${id}`,
        method: 'GET',
        header: {
          'Content-Type': 'application/json',
          'token': wx.getStorageSync('token')
        },
        success: function (res) {
          console.log("购物车数据:", res.data.data);
          var list = res.data.data;
          var deletes = [];
          var prompt = [];
          that.setData({
            judge: true,
            deletes: deletes,
            prompt: prompt
          });

          // 检查是否有已下架商品
          for (var i = 0; i < list.length; i++) {
            var item = list[i];
            
            if (item.goodsStatus == 1) {
              deletes.push(item.id);
              prompt.push(item.goodsName);
              that.setData({
                goodsstats: false,
                deletes: deletes,
                prompt: prompt,
                judge: false,
              });
            }
          }

          // 如果没有下架商品，继续处理支付流程
          if (that.data.judge) {
            that.setData({
              goodsstats: true,
            });
            var item = e.currentTarget.dataset.item;
            console.log("当前门店商品:", item);

            // 获取用户ID并清空本地购物车
            var user_id = String(app.globalData.userInfo.wxUserId);
            var cart = wx.getStorageSync(user_id);
            if (cart.length > 0) {
              cart.splice(0, cart.length);
              wx.setStorageSync(user_id, cart);
            }

            // 提取商品信息并构建购物车数据
            var storeID = item[0].storeId;
            var cart = [];
            for (var i = 0; i < item.length; i++) {
              var goodsItem = item[i];
              console.log(goodsItem)
              cart.push({
                id: goodsItem.goodsId,
                name: goodsItem.goodsName,
                cartprice: goodsItem.goodsPrice,
                quantity: parseInt(goodsItem.goodsNumber),
                coverUrl: goodsItem.goodsUrl,
                specification: goodsItem.goodsSpecName,
                categoriesId: goodsItem.categoriesId,
                specMultipleValue: goodsItem.specMultipleValue,
                quantity:goodsItem.totalNumber
              });
            }

            // 合并相同商品（按商品ID+规格+套餐）
            const mergedItemsMap = new Map();
            cart.forEach(cartItem => {
              // 生成唯一键：商品ID-规格-套餐
              const key = `${cartItem.id}-${cartItem.specification}-${cartItem.specMultipleValue}`;

              if (mergedItemsMap.has(key)) {
                // 已存在则合并数量
                const existingItem = mergedItemsMap.get(key);
                existingItem.goodsNumber += cartItem.goodsNumber;
              } else {
                // 新商品直接添加
                mergedItemsMap.set(key, {
                  ...cartItem
                });
              }
            });
            var mergedItemsMaps = Array.from(mergedItemsMap.values());
            console.log("合并后商品:", mergedItemsMaps);

            // 存储合并后的购物车数据
            wx.setStorageSync(user_id, mergedItemsMaps);

            // 检查所有商品库存
            let promises = mergedItemsMaps.map((cartItem) => {
              return new Promise((resolve, reject) => {
                wx.request({
                  url: `https://199shq.com/api/tproduct/${cartItem.id}`,
                  method: 'GET',
                  header: {
                    'Content-Type': 'application/json',
                    'token': wx.getStorageSync('token')
                  },
                  success: function (res) {
                    console.log("商品库存信息:", res.data.data);
                    let stockSufficient = true;

                    // 处理无规格商品
                    if (res.data.data.specification === 0) {
                      if (res.data.data.stock < cartItem.quantity) {
                        stockSufficient = false;
                        wx.showModal({
                          title: '库存不足',
                          content: `商品《${cartItem.name}》库存不足，请减少购买数量`,
                          showCancel: false,
                          confirmText: '知道了'
                        });
                      }
                    }
                    // 处理有规格商品
                    else {
                      let specStock = 0;
                      // 匹配规格对应的库存
                      if (cartItem.specification === res.data.data.specName) {
                        specStock = res.data.data.specStock;
                      } else if (cartItem.specification === res.data.data.specName2) {
                        specStock = res.data.data.specStock2;
                      } else if (cartItem.specification === res.data.data.specName3) {
                        specStock = res.data.data.specStock3;
                      } else if (cartItem.specification === res.data.data.specName4) {
                        specStock = res.data.data.specStock4;
                      } else {
                        // 规格不匹配
                        stockSufficient = false;
                        wx.showModal({
                          title: '规格错误',
                          content: `商品《${cartItem.name}》规格不存在，请重新选择`,
                          showCancel: false,
                          confirmText: '知道了'
                        });
                      }

                      // 检查库存是否足够
                      if (specStock < cartItem.quantity) {
                        stockSufficient = false;
                        wx.showModal({
                          title: '库存不足',
                          content: `商品《${cartItem.name}》(${cartItem.specification})库存不足，请减少购买数量`,
                          showCancel: false,
                          confirmText: '知道了'
                        });
                      }
                    }

                    resolve(stockSufficient);
                  },
                  fail: function (error) {
                    console.error("库存检查失败:", error);
                    reject(false);
                  }
                });
              });
            });

            // 等待所有库存检查完成
            Promise.all(promises).then((results) => {
              const allAvailable = results.every(available => available);

              if (allAvailable) {
                // 所有商品库存充足，跳转支付页面
                app.globalData.cat_ID = item;
                wx.navigateTo({
                  url: `../cesi2/cesi2?value=${storeID}&prices=${item[0].goodsPrice}&name=${item[0].goodsSpecName}`
                });
              } else {
                // 存在库存不足商品，阻止支付
                that.setData({
                  goodsstats: false
                });
              }
            }).catch(() => {
              // 库存检查请求失败
              that.setData({
                goodsstats: false
              });
              wx.showModal({
                title: '错误',
                content: '库存检查失败，请稍后重试',
                showCancel: false,
                confirmText: '知道了'
              });
            });
          } else {
            // 存在下架商品，提示删除
            that.showConfirmationDialog();
          }
        },
        fail: function (error) {
          console.error("获取购物车数据失败:", error);
          wx.showModal({
            title: '错误',
            content: '获取购物车数据失败，请稍后重试',
            showCancel: false,
            confirmText: '知道了'
          });
        }
      });
    },

    //验证用户是否登录如果未登录则跳转去登录页面
    verify: function () {
      var that = this;
      var app = getApp();
      if (!app.globalData.userInfo) {
        // // 如果用户未授权登录，则跳转到登录页面
        // wx.navigateTo({
        //   url: '/pages/about/about'
        // });
        // 如果用户未授权登录，则弹出提示框
        wx.showModal({
          title: '提示',
          content: '请先授权登录账号',
          showCancel: false,
          success: function (e) {
            if (e.confirm) {
              wx.navigateTo({
                url: '/pages/login/login',
              });
            }
          }
        });
      } else { //如果登录成功了则将用户id储存进入
        // console.log(app.globalData.userInfo);
        that.setData({
          user_id: String(app.globalData.userInfo.wxUserId)
        })
        console.log(this.data.user_id);
      }
    },

    onLoad: function () {
      if (wx.getUserProfile) {
        this.setData({
          canIUseGetUserProfile: true,
        });
      }
      this.getCarousels();
      this.getdata();
    },

    onShow() {
      this.getOrder();
      this.verify();
    },
    store(e) {
      console.log(e.currentTarget.dataset.storeid)
      wx.navigateTo({
        url: '../detail/detail?value=' + e.currentTarget.dataset.storeid,
      });
    },
    handleInput: function (e) {
      console.log(e)
      let value = e.currentTarget.dataset.goodsnumber;
      console.log(value)

      // 处理空值情况
      if (value === '') {
        value === 1
      }
      console.log(value)
      // 处理首位为0且长度超过1的情况（去掉首位0）
      if (value.length > 1 && value[0] === '0') {
        // 连续多个0的情况（如"000123"处理为"123"）
        value = value.replace(/^0+/, '');
        // 若处理后为空（如"0000"），保留一个0
        if (value === '') {
          value = '0';
        }
      }

      this.setData({
        inputValue: value,
        Totalprice: prices * value
      });
      // 禁止输入框编辑（需在wxml中配合disabled属性实现）
    },
    // 计算所有订单的总价并更新数据（保留原数据所有字段）
    calculateTotal() {                                                                                                        
      const orders = this.data.all;
      console.log(orders)
      const totals = orders.map(order => {
        console.log(order)
        // 计算单个订单的总价并保留两位小数
        return this.calculateSingleOrderTotal(order).toFixed(2);
      });

      console.log("订单总价数组:", totals);
      this.setData({
        orderTotals: totals // 更新总价数组
      });
    },

    // 计算单个订单的总价
    calculateSingleOrderTotal(goodsList) {
      return goodsList.reduce((sum, goods) => {
        return sum + (Number(goods.goodsPrice) * Number(goods.totalNumber));
      }, 0);
    },
    // ...
  });